home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 9 / FM Towns Free Software Collection 9.iso / t_os / tool / vdgear / src / effect.c < prev    next >
Text File  |  1994-11-16  |  11KB  |  623 lines
  1. /*
  2.  *    ＶＩＤＥＯ　ＧＥＡＲ
  3.  *    "effect.c"
  4.  *    by Good-Chy
  5.  */
  6.  
  7. #include    "video.h"
  8.  
  9. int    dx[2],dy[2],sx[2],sy[2];
  10. int    rnd[1200];
  11.  
  12. /******************************************************************************
  13.  *    エフェクト
  14.  */
  15.  
  16. /*
  17.  *    NO.1    ストライプ　縦
  18.  */
  19.  
  20. void    stripe1(int f)
  21.     {
  22.     char    *p1,*p2;
  23.  
  24.     if (flag[f] == 2)            /* 初期化 */
  25.         {
  26.         sx[f] =   0; sy[f] =   0;
  27.         dx[f] = 319; dy[f] = 239;
  28.         flag[f] = 3;
  29.         }
  30.  
  31.     if (flag[f] == 3)
  32.         {
  33.         if (f == 0)        /* クリア */
  34.             {
  35.             EGB_writePage(egb_work,1-f);
  36.             line(sx[f],sy[f],sx[f],dy[f],0x8000);
  37.             line(dx[f],sy[f],dx[f],dy[f],0x8000);
  38.             }
  39.         else                /* ピクチャ－コピ－ */
  40.             {
  41.             EGB_writePage(egb_work,0x80);
  42.             p1 = get_vram(32,sx[f],sy[f],sx[f],dy[f]);
  43.             p2 = get_vram(32,dx[f],sy[f],dx[f],dy[f]);
  44.             EGB_writePage(egb_work,1-f);
  45.             put_vram(p1,sx[f],sy[f],sx[f],dy[f]);
  46.             put_vram(p2,dx[f],sy[f],dx[f],dy[f]);
  47.             free(p1);
  48.             free(p2);
  49.             }
  50.  
  51.         sx[f] += 2; dx[f] -= 2;
  52.         if (dx[f]<0)    { flag[f] = 1; }
  53.         }
  54.     }
  55.  
  56. /*
  57.  *    NO.2    ストライプ　横
  58.  */
  59.  
  60. void    stripe2(int f)
  61.     {
  62.     char    *p1,*p2;
  63.  
  64.     if (flag[f] == 2)            /* 初期化 */
  65.         {
  66.         sx[f] =   0; sy[f] =   0;
  67.         dx[f] = 319; dy[f] = 239;
  68.         flag[f] = 3;
  69.         }
  70.  
  71.     if (flag[f] == 3)
  72.         {
  73.         if (f == 0)        /* クリア */
  74.             {
  75.             EGB_writePage(egb_work,1-f);
  76.             line(sx[f],sy[f],dx[f],sy[f],0x8000);
  77.             line(sx[f],dy[f],dx[f],dy[f],0x8000);
  78.             line(320,0,320,239,0x8000);
  79.             }
  80.         else                /* ピクチャ－コピ－ */
  81.             {
  82.             EGB_writePage(egb_work,0x80);
  83.             p1 = get_vram(32,sx[f],sy[f],dx[f],sy[f]);
  84.             p2 = get_vram(32,sx[f],dy[f],dx[f],dy[f]);
  85.             EGB_writePage(egb_work,1-f);
  86.             put_vram(p1,sx[f],sy[f],dx[f],sy[f]);
  87.             put_vram(p2,sx[f],dy[f],dx[f],dy[f]);
  88.             line(320,0,320,239,0x8000);
  89.             free(p1);
  90.             free(p2);
  91.             }
  92.  
  93.         sy[f] += 2; dy[f] -= 2;
  94.         if (dy[f]<0)    { flag[f] = 1; }
  95.         }
  96.     }
  97.  
  98. /*
  99.  *    NO.3    ワイプアップ
  100.  */
  101.  
  102. void    wipe_up(int f)
  103.     {
  104.     char    *p;
  105.  
  106.     if (flag[f] == 2)            /* 初期化 */
  107.         {
  108.         sy[f] =   239;
  109.         flag[f] = 3;
  110.         }
  111.  
  112.     if (flag[f] == 3)
  113.         {
  114.         if (f == 0)        /* クリア */
  115.             {
  116.             EGB_writePage(egb_work,1-f);
  117.             line(0,sy[f],319,sy[f],0x8000);
  118.             line(320,0,320,239,0x8000);
  119.             }
  120.         else                /* ピクチャ－コピ－ */
  121.             {
  122.             EGB_writePage(egb_work,0x80);
  123.             p = get_vram(32,0,sy[f],319,sy[f]);
  124.             EGB_writePage(egb_work,1-f);
  125.             put_vram(p,0,sy[f],319,sy[f]);
  126.             line(320,0,320,239,0x8000);
  127.             free(p);
  128.             }
  129.  
  130.         sy[f]--;
  131.         if (sy[f]<0)    { flag[f] = 1; }
  132.         }
  133.     }
  134.  
  135. /*
  136.  *    NO.4    ズ－ムイン
  137.  */
  138.  
  139. void    zoom_in(int    f)
  140.     {
  141.     char    *p1,*p2,*p3,*p4;
  142.  
  143.     if (flag[f] == 2)            /* 初期化 */
  144.         {
  145.         sx[f] = 119; sy[f] = 119;
  146.         dx[f] = 200; dy[f] = 120;
  147.         flag[f] = 3;
  148.         }
  149.  
  150.     if (flag[f] == 3)
  151.         {
  152.         if (f == 0)        /* クリア */
  153.             {
  154.             EGB_paintMode(egb_work,2);
  155.             EGB_writePage(egb_work,1-f);
  156.             box_full(sx[f],sy[f],dx[f],dy[f],0x8000,0x8000,0);
  157.             }
  158.         else                /* ピクチャ－コピ－ */
  159.             {
  160.             EGB_writePage(egb_work,0x80);
  161.             p1 = get_vram(32,sx[f],sy[f],dx[f],sy[f]);
  162.             p2 = get_vram(32,dx[f],sy[f],dx[f],dy[f]);
  163.             p3 = get_vram(32,sx[f],dy[f],dx[f],dy[f]);
  164.             p4 = get_vram(32,sx[f],sy[f],sx[f],dy[f]);
  165.             EGB_writePage(egb_work,1-f);
  166.             put_vram(p1,sx[f],sy[f],dx[f],sy[f]);
  167.             put_vram(p2,dx[f],sy[f],dx[f],dy[f]);
  168.             put_vram(p3,sx[f],dy[f],dx[f],dy[f]);
  169.             put_vram(p4,sx[f],sy[f],sx[f],dy[f]);
  170.             free(p1);
  171.             free(p2);
  172.             free(p3);
  173.             free(p4);
  174.             }
  175.  
  176.         sx[f]--; sy[f]--; dx[f]++; dy[f]++;
  177.         if (sx[f]<0)    { flag[f] = 1; }
  178.         }
  179.     }
  180.  
  181. /*
  182.  *    NO.5    バ－チカルオ－プン
  183.  */
  184.  
  185. void    verchcal_open(int f)
  186.     {
  187.     char    *p1,*p2;
  188.  
  189.     if (flag[f] == 2)            /* 初期化 */
  190.         {
  191.         sx[f] = 159; dx[f] = 160;
  192.         flag[f] = 3;
  193.         }
  194.  
  195.     if (flag[f] == 3)
  196.         {
  197.         if (f == 0)        /* クリア */
  198.             {
  199.             EGB_writePage(egb_work,1-f);
  200.             line(sx[f],0,sx[f],239,0x8000);
  201.             line(dx[f],0,dx[f],239,0x8000);
  202.             }
  203.         else                /* ピクチャ－コピ－ */
  204.             {
  205.             EGB_writePage(egb_work,0x80);
  206.             p1 = get_vram(32,sx[f],0,sx[f],239);
  207.             p2 = get_vram(32,dx[f],0,dx[f],239);
  208.             EGB_writePage(egb_work,1-f);
  209.             put_vram(p1,sx[f],0,sx[f],239);
  210.             put_vram(p2,dx[f],0,dx[f],239);
  211.             free(p1);
  212.             free(p2);
  213.             }
  214.  
  215.         sx[f]--; dx[f]++;
  216.         if (sx[f]<0)    { flag[f] = 1; }
  217.         }
  218.     }
  219.  
  220. /*
  221.  *    NO.6    ワイプダウン
  222.  */
  223.  
  224. void    wipe_down(int f)
  225.     {
  226.     char    *p;
  227.  
  228.     if (flag[f] == 2)            /* 初期化 */
  229.         {
  230.         sy[f] =   0;
  231.         flag[f] = 3;
  232.         }
  233.  
  234.     if (flag[f] == 3)
  235.         {
  236.         if (f == 0)        /* クリア */
  237.             {
  238.             EGB_writePage(egb_work,1-f);
  239.             line(0,sy[f],319,sy[f],0x8000);
  240.             line(320,0,320,239,0x8000);
  241.             }
  242.         else                /* ピクチャ－コピ－ */
  243.             {
  244.             EGB_writePage(egb_work,0x80);
  245.             p = get_vram(32,0,sy[f],319,sy[f]);
  246.             EGB_writePage(egb_work,1-f);
  247.             put_vram(p,0,sy[f],319,sy[f]);
  248.             line(320,0,320,239,0x8000);
  249.             free(p);
  250.             }
  251.  
  252.         sy[f]++;
  253.         if (sy[f]>240)    { flag[f] = 1; }
  254.         }
  255.     }
  256.  
  257. /*
  258.  *    NO.7    ズ－ムアウト
  259.  */
  260.  
  261. void    zoom_out(int f)
  262.     {
  263.     char    *p1,*p2,*p3,*p4;
  264.  
  265.     if (flag[f] == 2)            /* 初期化 */
  266.         {
  267.         sx[f] =   0; sy[f] = 0;
  268.         dx[f] = 319; dy[f] = 239;
  269.         flag[f] = 3;
  270.         }
  271.  
  272.     if (flag[f] == 3)
  273.         {
  274.         if (f == 0)        /* クリア */
  275.             {
  276.             EGB_paintMode(egb_work,2);
  277.             EGB_writePage(egb_work,1-f);
  278.             box_full(sx[f],sy[f],dx[f],dy[f],0x8000,0x8000,0);
  279.             }
  280.         else                /* ピクチャ－コピ－ */
  281.             {
  282.             EGB_writePage(egb_work,0x80);
  283.             p1 = get_vram(32,sx[f],sy[f],dx[f],sy[f]);
  284.             p2 = get_vram(32,dx[f],sy[f],dx[f],dy[f]);
  285.             p3 = get_vram(32,sx[f],dy[f],dx[f],dy[f]);
  286.             p4 = get_vram(32,sx[f],sy[f],sx[f],dy[f]);
  287.             EGB_writePage(egb_work,1-f);
  288.             put_vram(p1,sx[f],sy[f],dx[f],sy[f]);
  289.             put_vram(p2,dx[f],sy[f],dx[f],dy[f]);
  290.             put_vram(p3,sx[f],dy[f],dx[f],dy[f]);
  291.             put_vram(p4,sx[f],sy[f],sx[f],dy[f]);
  292.             free(p1);
  293.             free(p2);
  294.             free(p3);
  295.             free(p4);
  296.             }
  297.  
  298.         sx[f]++; sy[f]++; dx[f]--; dy[f]--;
  299.         if (sy[f]>120)    { flag[f] = 1; }
  300.         }
  301.     }
  302.  
  303. /*
  304.  *    NO.8    バ－チカルクロ－ズ
  305.  */
  306.  
  307. void    verchcal_close(int f)
  308.     {
  309.     char    *p1,*p2;
  310.  
  311.     if (flag[f] == 2)            /* 初期化 */
  312.         {
  313.         sx[f] = 0; dx[f] = 319;
  314.         flag[f] = 3;
  315.         }
  316.  
  317.     if (flag[f] == 3)
  318.         {
  319.         if (f == 0)        /* クリア */
  320.             {
  321.             EGB_writePage(egb_work,1-f);
  322.             line(sx[f],0,sx[f],239,0x8000);
  323.             line(dx[f],0,dx[f],239,0x8000);
  324.             }
  325.         else                /* ピクチャ－コピ－ */
  326.             {
  327.             EGB_writePage(egb_work,0x80);
  328.             p1 = get_vram(32,sx[f],0,sx[f],239);
  329.             p2 = get_vram(32,dx[f],0,dx[f],239);
  330.             EGB_writePage(egb_work,1-f);
  331.             put_vram(p1,sx[f],0,sx[f],239);
  332.             put_vram(p2,dx[f],0,dx[f],239);
  333.             free(p1);
  334.             free(p2);
  335.             }
  336.  
  337.         sx[f]++; dx[f]--;
  338.         if (sx[f]>160)    { flag[f] = 1; }
  339.         }
  340.     }
  341.  
  342. /*
  343.  *    NO.9    ワイプレフト
  344.  */
  345.  
  346. void    wipe_left(int f)
  347.     {
  348.     char    *p;
  349.  
  350.     if (flag[f] == 2)            /* 初期化 */
  351.         {
  352.         sx[f] =   319;
  353.         flag[f] = 3;
  354.         }
  355.  
  356.     if (flag[f] == 3)
  357.         {
  358.         if (f == 0)        /* クリア */
  359.             {
  360.             EGB_writePage(egb_work,1-f);
  361.             line(sx[f],0,sx[f],239,0x8000);
  362.             }
  363.         else                /* ピクチャ－コピ－ */
  364.             {
  365.             EGB_writePage(egb_work,0x80);
  366.             p = get_vram(32,sx[f],0,sx[f],239);
  367.             EGB_writePage(egb_work,1-f);
  368.             put_vram(p,sx[f],0,sx[f],239);
  369.             free(p);
  370.             }
  371.  
  372.         sx[f]--;
  373.         if (sx[f]<0)    { flag[f] = 1; }
  374.         }
  375.     }
  376.  
  377. /*
  378.  *    NO.10    ディゾルブ粗
  379.  */
  380.  
  381. void    dizorve1(int f)
  382.     {
  383.     int    i, a,b,c;
  384.     char    *p;
  385.  
  386.     if (flag[f] == 2)            /* 初期化 */
  387.         {
  388.         sx[f] = 299;
  389.  
  390.         for (i=0 ; i<300 ; i++)
  391.             { rnd[i] = i; }
  392.  
  393.         for (i=0 ; i<2000 ; i++)
  394.             {
  395.             a = rand()%300;
  396.             b = rand()%300;
  397.             c = rnd[a];
  398.             rnd[a] = rnd[b];
  399.             rnd[b] = c;
  400.             }
  401.         flag[f] = 3;
  402.         }
  403.  
  404.     if (flag[f] == 3)
  405.         {
  406.         a = rnd[sx[f]];
  407.         b = a/20;
  408.         c = a%20;
  409.  
  410.         if (f == 0)        /* クリア */
  411.             {
  412.             EGB_paintMode(egb_work,0x22);
  413.             EGB_writePage(egb_work,1-f);
  414.             box_full(c*16,b*16,c*16+15,b*16+15,0x8000,0x8000,0);
  415.             }
  416.         else                /* ピクチャ－コピ－ */
  417.             {
  418.             EGB_writePage(egb_work,0x80);
  419.             p = get_vram(32,c*16,b*16,c*16+15,b*16+15);
  420.             EGB_writePage(egb_work,1-f);
  421.             put_vram(p,c*16,b*16,c*16+15,b*16+15);
  422.             free(p);
  423.             }
  424.         sx[f]--;
  425.         if (sx[f]<0)    { flag[f] = 1; }
  426.         }
  427.     }
  428.  
  429. /*
  430.  *    NO.11    ホリゾンタルオ－プン
  431.  */
  432.  
  433. void    hrizontal_open(int f)
  434.     {
  435.     char    *p1,*p2;
  436.  
  437.     if (flag[f] == 2)            /* 初期化 */
  438.         {
  439.         sy[f] = 119; dy[f] = 120;
  440.         flag[f] = 3;
  441.         }
  442.  
  443.     if (flag[f] == 3)
  444.         {
  445.         if (f == 0)        /* クリア */
  446.             {
  447.             EGB_writePage(egb_work,1-f);
  448.             line(0,sy[f],319,sy[f],0x8000);
  449.             line(0,dy[f],319,dy[f],0x8000);
  450.             line(320,0,320,239,0x8000);
  451.             }
  452.         else                /* ピクチャ－コピ－ */
  453.             {
  454.             EGB_writePage(egb_work,0x80);
  455.             p1 = get_vram(32,0,sy[f],319,sy[f]);
  456.             p2 = get_vram(32,0,dy[f],319,dy[f]);
  457.             EGB_writePage(egb_work,1-f);
  458.             put_vram(p1,0,sy[f],319,sy[f]);
  459.             put_vram(p2,0,dy[f],319,dy[f]);
  460.             line(320,0,320,239,0x8000);
  461.             free(p1);
  462.             free(p2);
  463.             }
  464.  
  465.         sy[f]--; dy[f]++;
  466.         if (sy[f]<0)    { flag[f] = 1; }
  467.         }
  468.     }
  469.  
  470. /*
  471.  *    NO.12    ワイプライト
  472.  */
  473.  
  474. void    wipe_right(int f)
  475.     {
  476.     char    *p;
  477.  
  478.     if (flag[f] == 2)            /* 初期化 */
  479.         {
  480.         sx[f] =   0;
  481.         flag[f] = 3;
  482.         }
  483.  
  484.     if (flag[f] == 3)
  485.         {
  486.         if (f == 0)        /* クリア */
  487.             {
  488.             EGB_writePage(egb_work,1-f);
  489.             line(sx[f],0,sx[f],239,0x8000);
  490.             }
  491.         else                /* ピクチャ－コピ－ */
  492.             {
  493.             EGB_writePage(egb_work,0x80);
  494.             p = get_vram(32,sx[f],0,sx[f],239);
  495.             EGB_writePage(egb_work,1-f);
  496.             put_vram(p,sx[f],0,sx[f],239);
  497.             free(p);
  498.             }
  499.  
  500.         sx[f]++;
  501.         if (sx[f]>320)    { flag[f] = 1; }
  502.         }
  503.     }
  504.  
  505. /*
  506.  *    NO.13    ディゾルブ細
  507.  */
  508.  
  509. void    dizorve2(int f)
  510.     {
  511.     int    i, a,b,c;
  512.     char    *p;
  513.  
  514.     if (flag[f] == 2)            /* 初期化 */
  515.         {
  516.         sx[f] = 1199;
  517.  
  518.         for (i=0 ; i<1200 ; i++)
  519.             { rnd[i] = i; }
  520.  
  521.         for (i=0 ; i<2000 ; i++)
  522.             {
  523.             a = rand()%1200;
  524.             b = rand()%1200;
  525.             c = rnd[a];
  526.             rnd[a] = rnd[b];
  527.             rnd[b] = c;
  528.             }
  529.         flag[f] = 3;
  530.         }
  531.  
  532.     if (flag[f] == 3)
  533.         {
  534.         a = rnd[sx[f]];
  535.         b = a/40;
  536.         c = a%40;
  537.  
  538.         if (f == 0)        /* クリア */
  539.             {
  540.             EGB_paintMode(egb_work,0x22);
  541.             EGB_writePage(egb_work,1-f);
  542.             box_full(c*8,b*8,c*8+7,b*8+7,0x8000,0x8000,0);
  543.             }
  544.         else                /* ピクチャ－コピ－ */
  545.             {
  546.             EGB_writePage(egb_work,0x80);
  547.             p = get_vram(32,c*8,b*8,c*8+7,b*8+7);
  548.             EGB_writePage(egb_work,1-f);
  549.             put_vram(p,c*8,b*8,c*8+7,b*8+7);
  550.             free(p);
  551.             }
  552.         sx[f]--;
  553.         if (sx[f]<0)    { flag[f] = 1; }
  554.         }
  555.     }
  556.  
  557. /*
  558.  *    NO.11    ホリゾンタルクロ－ズ
  559.  */
  560.  
  561. void    hrizontal_close(int f)
  562.     {
  563.     char    *p1,*p2;
  564.  
  565.     if (flag[f] == 2)            /* 初期化 */
  566.         {
  567.         sy[f] = 0; dy[f] = 239;
  568.         flag[f] = 3;
  569.         }
  570.  
  571.     if (flag[f] == 3)
  572.         {
  573.         if (f == 0)        /* クリア */
  574.             {
  575.             EGB_writePage(egb_work,1-f);
  576.             line(0,sy[f],319,sy[f],0x8000);
  577.             line(0,dy[f],319,dy[f],0x8000);
  578.             line(320,0,320,239,0x8000);
  579.             }
  580.         else                /* ピクチャ－コピ－ */
  581.             {
  582.             EGB_writePage(egb_work,0x80);
  583.             p1 = get_vram(32,0,sy[f],319,sy[f]);
  584.             p2 = get_vram(32,0,dy[f],319,dy[f]);
  585.             EGB_writePage(egb_work,1-f);
  586.             put_vram(p1,0,sy[f],319,sy[f]);
  587.             put_vram(p2,0,dy[f],319,dy[f]);
  588.             line(320,0,320,239,0x8000);
  589.             free(p1);
  590.             free(p2);
  591.             }
  592.  
  593.         sy[f]++; dy[f]--;
  594.         if (sy[f]>120)    { flag[f] = 1; }
  595.         }
  596.     }
  597.  
  598. /*
  599.  *    NO.15    効果無し
  600.  */
  601.  
  602. void    nothing(int f)
  603.     {
  604.     char    *p;
  605.  
  606.     if (f == 0)        /* クリア */
  607.         {
  608.         EGB_writePage(egb_work,1-f);
  609.         EGB_color(egb_work,1,0x8000);
  610.         EGB_clearScreen(egb_work);
  611.         }
  612.     else                /* ピクチャ－コピ－ */
  613.         {
  614.         EGB_writePage(egb_work,0x80);
  615.         p = get_vram(32,0,0,319,239);
  616.         EGB_writePage(egb_work,1-f);
  617.         put_vram(p,0,0,319,239);
  618.         free(p);
  619.         }
  620.  
  621.     flag[f] = 1;
  622.     }
  623.